/*
 * MIT许可证
 *
 * 版权所有 (c) 2025-2035 JacobGreen
 *
 * 特此免费授予获得本软件及相关文档文件（"软件"）副本的任何人不受限制地处置该软件的权利，
 * 包括不限于使用、复制、修改、合并、发布、分发、再许可和/或出售该软件副本，
 * 以及允许被提供该软件的人这样做，须遵守以下条件：
 *
 * 上述版权声明和本许可声明应包含在该软件的所有副本或实质性部分中。
 *
 * 本软件按"原样"提供，不附带任何形式的明示或暗示的保证，
 * 包括但不限于对适销性、特定用途适用性和不侵权的保证。
 * 在任何情况下，作者或版权持有人均不对任何索赔、损害或其他
 * 责任负责，无论是在合同行为、侵权行为或其他方面，
 * 与软件或软件的使用或其他交易有关。
 */

#include "ArrayList.h"
#include "Log.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// 函数前向声明
// 数据操作
static bool arrayListAdd(struct ArrayList *self, void *element);
static bool arrayListRemove(struct ArrayList *self, void *element, int (*compare)(void *, void *));
static bool arrayListContains(struct ArrayList *self, void *data, int (*compare)(void *, void *));
static int arrayListIndexOf(struct ArrayList *self, void *data, int (*compare)(void *, void *));
static int arrayListLastIndexOf(struct ArrayList *self, void *data, int (*compare)(void *, void *));
static void arrayListReplaceAll(struct ArrayList *self, void *data, bool (*compare)(void *, void *));

// 索引操作
static bool arrayListAddIndex(struct ArrayList *self, int index, void *element);
static bool arrayListAddFirst(struct ArrayList *self, void *element);
static bool arrayListAddLast(struct ArrayList *self, void *element);
static void *arrayListRemoveIndex(struct ArrayList *self, int index);
static void *arrayListRemoveFirst(struct ArrayList *self);
static void *arrayListRemoveLast(struct ArrayList *self);
static void *arrayListSet(struct ArrayList *self, int index, void *data);
static void *arrayListSetFirst(struct ArrayList *self, void *data);
static void *arrayListSetLast(struct ArrayList *self, void *data);
static void *arrayListGet(struct ArrayList *self, int index);
static void *arrayListGetFirst(struct ArrayList *self);
static void *arrayListGetLast(struct ArrayList *self);

// 集合操作操作
static bool arrayListAddAll(struct ArrayList *self, struct ArrayList *other);
static bool arrayListRemoveAll(struct ArrayList *self, struct ArrayList *other, int (*compare)(void *, void *));
static bool arrayListRetainAll(struct ArrayList *self, struct ArrayList *other, int (*compare)(void *, void *));
static bool arrayListContainsAll(struct ArrayList *self, struct ArrayList *other, int (*compare)(void *, void *));
static bool arrayListMerge(struct ArrayList *self, struct ArrayList *other);
static bool arrayListEquals(struct ArrayList *self, struct ArrayList *other, int (*compare)(void *, void *));
static struct ArrayList *arrayListClone(struct ArrayList *self);
static struct ArrayList *arrayListSubList(struct ArrayList *self, int fromIndex, int toIndex);
static struct ArrayList **arrayListSplit(struct ArrayList *self, int index);
static struct ArrayList **arrayListGroup(struct ArrayList *self, int (*group)(void *));

// 列表操作
static char *arrayListToString(struct ArrayList *self);
static int arrayListHashCode(struct ArrayList *self);
static bool arrayListIsEmpty(struct ArrayList *self);
static bool arrayListAddAllIndex(struct ArrayList *self, int index, struct ArrayList *other);
static bool arrayListRemoveRange(struct ArrayList *self, int fromIndex, int toIndex);
static bool arrayListTruncate(struct ArrayList *self, int newSize);
static bool arrayListClear(struct ArrayList *self);
static void arrayListForEach(struct ArrayList *self, void (*action)(void *));
static void arrayListForEachReverse(struct ArrayList *self, void (*action)(void *));
static void arrayListReverse(struct ArrayList *self);
static void arrayListSort(struct ArrayList *self, int type, int (*compare)(void *, void *));

// 快速排序辅助函数
static void quickSort(void **data, int low, int high, int type, int (*compare)(void *, void *));
static int partition(void **data, int low, int high, int type, int (*compare)(void *, void *));

// 属性操作
static int arrayListGetSize(struct ArrayList *self);
static int arrayListGetCapacity(struct ArrayList *self);
static bool arrayListEnsureCapacity(struct ArrayList *self, int minCapacity);

// 创建和销毁

/**
 * 创建一个新的ArrayList
 * @param capacity 初始容量
 * @return ArrayList指针
 */
struct ArrayList *arrayListInit(int capacity) {
    // 验证容量参数
    if (capacity <= 0) {
        LOG_WARN("数组表", "初始化", "输入容量无效(%d),使用默认容量(%d)", capacity, DEFAULT_CAPACITY);
        capacity = DEFAULT_CAPACITY;
    }
    
    // 分配ArrayList结构体内存
    ArrayList *list = (ArrayList *)malloc(sizeof(ArrayList));
    if (list == NULL) {
        LOG_ERROR("数组表", "初始化", "内存分配失败,初始化失败");
        return NULL; // 内存分配失败
    }
    
    // 分配数据数组内存
    list->data = (void **)malloc(sizeof(void *) * capacity);
    if (list->data == NULL) {
        LOG_ERROR("数组表", "初始化", "数据数组内存分配失败,初始化失败");
        free(list); // 释放结构体内存
        return NULL; // 内存分配失败
    }
    
    // 初始化基本属性
    list->size = 0;
    list->capacity = capacity;
    
    // 初始化所有函数指针为NULL，避免野指针
    // 数据操作
    list->add = arrayListAdd;
    list->remove = arrayListRemove;
    list->contains = arrayListContains;
    list->indexOf = arrayListIndexOf;
    list->lastIndexOf = arrayListLastIndexOf;
    list->replaceAll = arrayListReplaceAll;
    // 索引操作
    list->addIndex = arrayListAddIndex;
    list->addFirst = arrayListAddFirst;
    list->addLast = arrayListAddLast;
    list->removeIndex = arrayListRemoveIndex;
    list->removeFirst = arrayListRemoveFirst;
    list->removeLast = arrayListRemoveLast;
    list->set = arrayListSet;
    list->setFirst = arrayListSetFirst;
    list->setLast = arrayListSetLast;
    list->get = arrayListGet;
    list->getFirst = arrayListGetFirst;
    list->getLast = arrayListGetLast;
    // 集合操作
    list->addAll = arrayListAddAll;
    list->removeAll = arrayListRemoveAll;
    list->retainAll = arrayListRetainAll;
    list->containsAll = arrayListContainsAll;
    list->merge = arrayListMerge;
    list->equals = arrayListEquals;
    list->clone = arrayListClone;
    list->subList = arrayListSubList;
    list->split = arrayListSplit;
    list->group = arrayListGroup;
    //列表操作
    list->toString = arrayListToString;
    list->hashCode = arrayListHashCode;
    list->isEmpty = arrayListIsEmpty;
    list->addAllIndex = arrayListAddAllIndex;
    list->removeRange = arrayListRemoveRange;
    list->truncate = arrayListTruncate;
    list->clear = arrayListClear;
    list->forEach = arrayListForEach;
    list->forEachReverse = arrayListForEachReverse;
    list->reverse = arrayListReverse;
    list->sort = arrayListSort;
    // 属性操作
    list->getSize = arrayListGetSize;
    list->getCapacity = arrayListGetCapacity;
    list->ensureCapacity = arrayListEnsureCapacity;
    return list;
}

/**
 * 销毁ArrayList
 * @param list ArrayList指针
 */
void arrayListDestroy(struct ArrayList *list) {
    if (list == NULL) {
        LOG_WARN("数组表", "销毁", "数组表指针为空,无需销毁");
        return; // 空指针检查
    }
    
    // 释放数据数组内存
    if (list->data != NULL) {
        free(list->data);
        list->data = NULL;
    }
    
    // 释放ArrayList结构体内存
    free(list);
}

// 数据操作

/**
 * 替换数组表中所有满足条件的元素
 * @param self ArrayList指针
 * @param data 用于替换的新元素指针
 * @param compare 比较函数，用于判断元素是否需要被替换
 */
static void arrayListReplaceAll(struct ArrayList *self, void *data, bool (*compare)(void *, void *)) {
    // 参数验证
    if (self == NULL) {
        LOG_ERROR("数组表", "替换元素", "数组表指针为空");
        return;
    }
    
    if (compare == NULL) {
        LOG_ERROR("数组表", "替换元素", "比较函数指针为空");
        return;
    }
    
    // 检查数组表是否为空
    if (self->size == 0) {
        LOG_DEBUG("数组表", "替换元素", "数组表为空，无需替换");
        return;
    }
    
    // 遍历数组表，替换满足条件的元素
    for (int i = 0; i < self->size; i++) {
        if (compare(self->data[i], data)) {
            self->data[i] = data; // 替换元素
            LOG_DEBUG("数组表", "替换元素", "索引(%d)的元素已被替换", i);
        }
    }
    
    LOG_DEBUG("数组表", "替换元素", "替换操作完成，数组表大小为(%d)", self->size);
}

/**
 * 向ArrayList末尾添加元素
 * @param self ArrayList指针
 * @param element 要添加的元素指针
 * @return 是否添加成功
 */
static bool arrayListAdd(struct ArrayList *self, void *element) {
    if (self == NULL) {
        LOG_ERROR("数组表", "添加元素", "数组表指针为空");
        return false;
    }
    
    // 检查是否需要扩容
    if (self->size >= self->capacity) {
        if (!arrayListEnsureCapacity(self, self->size + 1)) {
            LOG_ERROR("数组表", "添加元素", "容量不足且扩容失败");
            return false;
        }
    }
    
    // 添加元素到末尾
    self->data[self->size] = element;
    self->size++;
    
    LOG_INFO("数组表", "添加元素", "成功添加元素到索引 %d", self->size - 1);
    return true;
}


/**
 * 从ArrayList中删除指定元素
 * @param self ArrayList指针
 * @param element 要删除的元素
 * @param compare 比较函数，返回0表示元素相等
 * @return 是否删除成功
 */
static bool arrayListRemove(struct ArrayList *self, void *element, int (*compare)(void *, void *)) {
    // 检查参数有效性
    if (self == NULL) {
        LOG_ERROR("数组表", "删除元素", "数组表指针为空");
        return false;
    }
    
    if (compare == NULL) {
        LOG_ERROR("数组表", "删除元素", "比较函数指针为空");
        return false;
    }
    
    // 检查列表是否为空
    if (self->size == 0) {
        LOG_ERROR("数组表", "删除元素", "数组表为空，无法删除元素");
        return false;
    }
    
    // 遍历列表查找元素
    for (int i = 0; i < self->size; i++) {
        // 使用比较函数判断元素是否相等
        if (compare(self->data[i], element) == 0) {
            // 找到元素，调用removeIndex函数删除
            return arrayListRemoveIndex(self, i);
        }
    }
    
    // 未找到元素
    LOG_INFO("数组表", "删除元素", "未找到要删除的元素");
    return false;
}

/**
 * 判断数组表是否包含指定元素
 * @param self ArrayList指针
 * @param data 要判断的元素指针
 * @param compare 比较函数指针，返回0表示元素相等
 * @return 是否包含指定元素
 */
static bool arrayListContains(struct ArrayList *self, void *data, int (*compare)(void *, void *)) {
    // 检查参数有效性
    if (self == NULL) {
        LOG_ERROR("数组表", "包含元素", "数组表指针为空");
        return false;
    }
    
    if (compare == NULL) {
        LOG_ERROR("数组表", "包含元素", "比较函数指针为空");
        return false;
    }
    
    // 检查列表是否为空
    if (self->size == 0) {
        LOG_INFO("数组表", "包含元素", "数组表为空，不包含任何元素");
        return false;
    }
    
    // 遍历列表查找元素
    for (int i = 0; i < self->size; i++) {
        // 使用比较函数判断元素是否相等
        if (compare(self->data[i], data) == 0) {
            LOG_INFO("数组表", "包含元素", "在索引 %d 处找到元素", i);
            return true;
        }
    }
    
    // 没有找到元素
    LOG_INFO("数组表", "包含元素", "未找到指定元素");
    return false;
}

/**
 * <p>
 * 获取数组表中指定元素首次出现的位置索引
 * </p>
 * 
 * @param self 数组表指针
 * @param data 要获取索引的元素指针
 * @param compare 比较函数指针
 * @return 第一个出现位置索引，若不存在则返回-1
 */
static int arrayListIndexOf(struct ArrayList *self, void *data, int (*compare)(void *, void *)) {
    // 检查参数有效性
    if (self == NULL) {
        LOG_ERROR("数组表", "获取首次索引", "数组表指针为空");
        return -1;
    }
    
    if (data == NULL) {
        LOG_ERROR("数组表", "获取首次索引", "数据指针为空");
        return -1;
    }
    
    if (compare == NULL) {
        LOG_ERROR("数组表", "获取首次索引", "比较函数指针为空");
        return -1;
    }
    
    // 检查列表是否为空
    if (self->size == 0) {
        LOG_INFO("数组表", "获取首次索引", "数组表为空，不包含任何元素");
        return -1;
    }
    
    // 从前往后遍历列表查找元素
    for (int i = 0; i < self->size; i++) {
        // 使用比较函数判断元素是否相等
        if (compare(self->data[i], data) == 0) {
            LOG_INFO("数组表", "获取首次索引", "在索引 %d 处找到第一个匹配元素", i);
            return i;
        }
    }
    
    // 没有找到元素
    LOG_INFO("数组表", "获取首次索引", "未找到指定元素");
    return -1;
}

/**
 * <p>
 * 获取数组表中指定元素最后一次出现的位置索引
 * </p>
 * 
 * @param self 数组表指针
 * @param data 要获取索引的元素指针
 * @param compare 比较函数指针
 * @return 最后一个出现位置索引，若不存在则返回-1
 */
static int arrayListLastIndexOf(struct ArrayList *self, void *data, int (*compare)(void *, void *)) {
    // 检查参数有效性
    if (self == NULL) {
        LOG_ERROR("数组表", "获取最后索引", "数组表指针为空");
        return -1;
    }
    
    if (data == NULL) {
        LOG_ERROR("数组表", "获取最后索引", "数据指针为空");
        return -1;
    }
    
    if (compare == NULL) {
        LOG_ERROR("数组表", "获取最后索引", "比较函数指针为空");
        return -1;
    }
    
    // 检查列表是否为空
    if (self->size == 0) {
        LOG_INFO("数组表", "获取最后索引", "数组表为空，不包含任何元素");
        return -1;
    }
    
    // 从后往前遍历列表查找元素
    for (int i = self->size - 1; i >= 0; i--) {
        // 使用比较函数判断元素是否相等
        if (compare(self->data[i], data) == 0) {
            LOG_INFO("数组表", "获取最后索引", "在索引 %d 处找到最后一个匹配元素", i);
            return i;
        }
    }
    
    // 没有找到元素
    LOG_INFO("数组表", "获取最后索引", "未找到指定元素");
    return -1;
}

// 索引操作

/**
 * 在指定索引位置添加元素
 * @param self ArrayList指针
 * @param index 添加位置的索引
 * @param element 要添加的元素指针
 * @return 是否添加成功
 */
static bool arrayListAddIndex(struct ArrayList *self, int index, void *element) {
    // 检查参数有效性
    if (self == NULL) {
        LOG_ERROR("数组表", "指定索引添加", "数组表指针为空");
        return false;
    }
    
    // 检查索引是否有效
    // 允许index等于size，表示添加到末尾（等同于add）
    if (index < 0 || index > self->size) {
        LOG_ERROR("数组表", "指定索引添加", "索引 %d 无效，有效范围为 [0, %d]", index, self->size);
        return false;
    }
    
    // 检查是否需要扩容
    if (self->size >= self->capacity) {
        if (!arrayListEnsureCapacity(self, self->size + 1)) {
            LOG_ERROR("数组表", "指定索引添加", "容量不足且扩容失败");
            return false;
        }
    }
    
    // 如果不是添加到末尾，需要将后续元素后移
    if (index < self->size) {
        // 从最后一个元素开始，依次后移一位
        for (int i = self->size; i > index; i--) {
            self->data[i] = self->data[i - 1];
        }
    }
    
    // 在指定索引位置添加元素
    self->data[index] = element;
    self->size++;
    
    LOG_INFO("数组表", "指定索引添加", "成功在索引 %d 添加元素", index);
    return true;
}

/**
 * 添加元素到ArrayList开头
 * @param self ArrayList指针
 * @param element 要添加的元素指针
 * @return 是否添加成功
 */
static bool arrayListAddFirst(struct ArrayList *self, void *element) {
    // 调用addIndex函数在索引0处添加元素，复用已实现的功能
    return arrayListAddIndex(self, 0, element);
}

/**
 * 添加元素到ArrayList末尾（等同于add函数）
 * @param self ArrayList指针
 * @param element 要添加的元素指针
 * @return 是否添加成功
 */
static bool arrayListAddLast(struct ArrayList *self, void *element) {
    // 直接调用add函数，复用已实现的功能
    return arrayListAdd(self, element);
}

/**
 * 从ArrayList中删除指定索引位置的元素
 * @param self ArrayList指针
 * @param index 要删除元素的索引
 * @return 是否删除成功
 */
static void *arrayListRemoveIndex(struct ArrayList *self, int index) {
    // 检查参数有效性
    if (self == NULL) {
        LOG_ERROR("数组表", "指定索引删除", "数组表指针为空");
        return NULL;
    }
    
    // 检查索引是否有效
    if (index < 0 || index >= self->size) {
        LOG_ERROR("数组表", "指定索引删除", "索引 %d 无效，有效范围为 [0, %d]", index, self->size - 1);
        return NULL;
    }
    
    // 保存要删除的元素
    void *removedElement = self->data[index];
    
    // 将后续元素前移一位，覆盖要删除的元素
    for (int i = index; i < self->size - 1; i++) {
        self->data[i] = self->data[i + 1];
    }
    
    // 将末尾元素置为NULL
    self->data[self->size - 1] = NULL;
    
    // 更新大小
    self->size--;
    
    LOG_INFO("数组表", "指定索引删除", "成功删除索引 %d 的元素", index);
    return removedElement;
}

/**
 * 从ArrayList中删除第一个元素
 * @param self ArrayList指针
 * @return 是否删除成功
 */
static void *arrayListRemoveFirst(struct ArrayList *self) {
    // 调用removeIndex函数在索引0处删除元素，复用已实现的功能
    return arrayListRemoveIndex(self, 0);
}

/**
 * 从ArrayList中删除最后一个元素
 * @param self ArrayList指针
 * @return 是否删除成功
 */
static void *arrayListRemoveLast(struct ArrayList *self) {
    // 调用removeIndex函数在最后一个元素的索引位置删除元素
    return arrayListRemoveIndex(self, self->size - 1);
}

/**
 * 替换数组表中指定位置的元素
 * @param self ArrayList指针
 * @param index 要替换的位置索引
 * @param element 新元素指针
 * @return 被替换的旧元素指针，若参数无效或索引越界则返回NULL
 */
static void *arrayListSet(struct ArrayList *self, int index, void *element) {
    // 参数有效性检查
    if (self == NULL) {
        LOG_ERROR("数组表", "设置元素", "参数self为NULL，返回NULL");
        return NULL;
    }
    
    // 索引范围检查
    if (index < 0 || index >= self->size) {
        LOG_ERROR("数组表", "设置元素", "索引越界: %d，有效范围: 0-%d", index, self->size - 1);
        return NULL;
    }
    
    // 保存旧元素指针以便返回
    void *oldElement = self->data[index];
    
    // 设置新元素
    self->data[index] = element;
    
    LOG_INFO("数组表", "设置元素", "成功替换索引 %d 的元素", index);
    
    // 返回被替换的旧元素
    return oldElement;
}

/**
 * 替换数组表的第一个元素
 * @param self ArrayList指针
 * @param element 新元素指针
 * @return 被替换的旧元素指针，若参数无效或数组表为空则返回NULL
 */
static void *arrayListSetFirst(struct ArrayList *self, void *element) {
    // 参数有效性检查
    if (self == NULL) {
        LOG_ERROR("数组表", "设置第一个元素", "参数self为NULL，返回NULL");
        return NULL;
    }
    
    // 检查数组表是否为空
    if (self->size == 0) {
        LOG_ERROR("数组表", "设置第一个元素", "数组表为空，无法设置第一个元素");
        return NULL;
    }
    
    // 保存旧元素指针以便返回
    void *oldElement = self->data[0];
    
    // 设置新元素到第一个位置
    self->data[0] = element;
    
    LOG_INFO("数组表", "设置第一个元素", "成功替换第一个元素");
    
    // 返回被替换的旧元素
    return oldElement;
}

/**
 * 替换数组表的最后一个元素
 * @param self ArrayList指针
 * @param element 新元素指针
 * @return 被替换的旧元素指针，若参数无效或数组表为空则返回NULL
 */
static void *arrayListSetLast(struct ArrayList *self, void *element) {
    // 参数有效性检查
    if (self == NULL) {
        LOG_ERROR("数组表", "设置最后一个元素", "参数self为NULL，返回NULL");
        return NULL;
    }
    
    // 检查数组表是否为空
    if (self->size == 0) {
        LOG_ERROR("数组表", "设置最后一个元素", "数组表为空，无法设置最后一个元素");
        return NULL;
    }
    
    // 保存旧元素指针以便返回
    void *oldElement = self->data[self->size - 1];
    
    // 设置新元素到最后一个位置
    self->data[self->size - 1] = element;
    
    LOG_INFO("数组表", "设置最后一个元素", "成功替换最后一个元素");
    
    // 返回被替换的旧元素
    return oldElement;
}

/**
 * 获取数组表中指定位置的元素
 * @param self ArrayList指针
 * @param index 要获取的位置索引
 * @return 元素指针，若参数无效或索引越界则返回NULL
 */
static void *arrayListGet(struct ArrayList *self, int index) {
    // 参数有效性检查
    if (self == NULL) {
        LOG_ERROR("数组表", "获取元素", "参数为NULL，返回NULL");
        return NULL;
    }
    
    // 索引范围检查
    if (index < 0 || index >= self->size) {
        LOG_ERROR("数组表", "获取元素", "索引越界: %d，有效范围: 0-%d", index, self->size - 1);
        return NULL;
    }
    
    LOG_INFO("数组表", "获取元素", "成功获取索引 %d 的元素", index);
    
    // 返回指定索引位置的元素
    return self->data[index];
}

/**
 * 获取数组表的第一个元素
 * @param self ArrayList指针
 * @return 第一个元素指针，若参数无效或数组表为空则返回NULL
 */
static void *arrayListGetFirst(struct ArrayList *self) {
    // 参数有效性检查
    if (self == NULL) {
        LOG_ERROR("数组表", "获取第一个元素", "参数为NULL，返回NULL");
        return NULL;
    }
    
    // 检查数组表是否为空
    if (self->size == 0) {
        LOG_ERROR("数组表", "获取第一个元素", "数组表为空，无法获取第一个元素");
        return NULL;
    }
    
    LOG_INFO("数组表", "获取第一个元素", "成功获取第一个元素");
    
    // 返回第一个元素
    return self->data[0];
}

/**
 * 获取数组表的最后一个元素
 * @param self ArrayList指针
 * @return 最后一个元素指针，若参数无效或数组表为空则返回NULL
 */
static void *arrayListGetLast(struct ArrayList *self) {
    // 参数有效性检查
    if (self == NULL) {
        LOG_ERROR("数组表", "获取最后一个元素", "参数为NULL，返回NULL");
        return NULL;
    }
    
    // 检查数组表是否为空
    if (self->size == 0) {
        LOG_ERROR("数组表", "获取最后一个元素", "数组表为空，无法获取最后一个元素");
        return NULL;
    }
    
    LOG_INFO("数组表", "获取最后一个元素", "成功获取最后一个元素");
    
    // 返回最后一个元素
    return self->data[self->size - 1];
}

// 集合操作

/**
 * 将另一个ArrayList中的所有元素添加到当前ArrayList末尾
 * @param self ArrayList指针
 * @param other 另一个ArrayList指针
 * @return 是否添加成功
 */
static bool arrayListAddAll(struct ArrayList *self, struct ArrayList *other) {
    // 检查参数有效性
    if (self == NULL) {
        LOG_ERROR("数组表", "添加列表", "数组表指针为空");
        return false;
    }
    
    if (other == NULL) {
        LOG_WARN("数组表", "添加列表", "源数组表指针为空");
        return true; // 空列表视为成功添加（没有元素需要添加）
    }
    
    // 如果other列表为空，直接返回成功
    if (other->size == 0) {
        LOG_INFO("数组表", "添加列表", "源数组表为空，无需添加");
        return true;
    }
    
    // 计算添加后的总大小
    int newSize = self->size + other->size;
    
    // 确保有足够的容量
    if (newSize > self->capacity) {
        if (!arrayListEnsureCapacity(self, newSize)) {
            LOG_ERROR("数组表", "添加列表", "容量不足且扩容失败");
            return false;
        }
    }
    
    // 批量复制元素
    for (int i = 0; i < other->size; i++) {
        self->data[self->size + i] = other->data[i];
    }
    
    // 更新大小
    self->size = newSize;
    
    LOG_INFO("数组表", "添加列表", "成功添加 %d 个元素到列表末尾", other->size);
    return true;
}

/**
 * 从ArrayList中移除与另一个ArrayList中相同的所有元素（集合做减法）
 * @param self 当前ArrayList指针
 * @param other 另一个ArrayList指针
 * @param compare 比较函数，返回0表示元素相等
 * @return 是否删除成功
 */
static bool arrayListRemoveAll(struct ArrayList *self, struct ArrayList *other, int (*compare)(void *, void *)) {
    // 检查参数有效性
    if (self == NULL) {
        LOG_ERROR("数组表", "移除列表元素", "数组表指针为空");
        return false;
    }
    
    if (other == NULL) {
        LOG_WARN("数组表", "移除列表元素", "源数组表指针为空，无元素需要移除");
        return true; // 空列表视为成功（没有元素需要移除）
    }
    
    if (compare == NULL) {
        LOG_ERROR("数组表", "移除列表元素", "比较函数指针为空");
        return false;
    }
    
    // 如果self列表为空，直接返回成功
    if (self->size == 0) {
        LOG_INFO("数组表", "移除列表元素", "数组表为空，无需移除元素");
        return true;
    }
    
    // 如果other列表为空，直接返回成功
    if (other->size == 0) {
        LOG_INFO("数组表", "移除列表元素", "源数组表为空，无需移除元素");
        return true;
    }
    
    // 标记需要保留的元素
    int newSize = 0;
    for (int i = 0; i < self->size; i++) {
        bool found = false;
        // 检查当前元素是否存在于other列表中
        for (int j = 0; j < other->size; j++) {
            if (compare(self->data[i], other->data[j]) == 0) {
                found = true;
                break;
            }
        }
        
        // 如果元素不存在于other列表中，保留它
        if (!found) {
            self->data[newSize] = self->data[i];
            newSize++;
        }
    }
    
    // 记录删除的元素数量
    int removedCount = self->size - newSize;
    
    // 更新大小
    self->size = newSize;
    
    LOG_INFO("数组表", "移除列表元素", "成功移除 %d 个元素", removedCount);
    return true;
}

/**
 * 保留ArrayList中与另一个ArrayList中相同的所有元素（集合做交集）
 * @param self 当前ArrayList指针
 * @param other 另一个ArrayList指针
 * @param compare 比较函数，返回0表示元素相等
 * @return 是否操作成功
 */
static bool arrayListRetainAll(struct ArrayList *self, struct ArrayList *other, int (*compare)(void *, void *)) {
    // 检查参数有效性
    if (self == NULL) {
        LOG_ERROR("数组表", "保留列表元素", "数组表指针为空");
        return false;
    }
    
    if (other == NULL) {
        LOG_WARN("数组表", "保留列表元素", "源数组表指针为空，清空当前数组表");
        self->size = 0; // 清空当前列表
        return true;
    }
    
    if (compare == NULL) {
        LOG_ERROR("数组表", "保留列表元素", "比较函数指针为空");
        return false;
    }
    
    // 如果self列表为空，直接返回成功
    if (self->size == 0) {
        LOG_INFO("数组表", "保留列表元素", "数组表为空，无需保留元素");
        return true;
    }
    
    // 如果other列表为空，清空self列表
    if (other->size == 0) {
        LOG_INFO("数组表", "保留列表元素", "源数组表为空，清空当前数组表");
        self->size = 0;
        return true;
    }
    
    // 标记需要保留的元素
    int newSize = 0;
    for (int i = 0; i < self->size; i++) {
        bool found = false;
        // 检查当前元素是否存在于other列表中
        for (int j = 0; j < other->size; j++) {
            if (compare(self->data[i], other->data[j]) == 0) {
                found = true;
                break;
            }
        }
        
        // 如果元素存在于other列表中，保留它
        if (found) {
            self->data[newSize] = self->data[i];
            newSize++;
        }
    }
    
    // 记录保留的元素数量
    int retainedCount = newSize;
    
    // 更新大小
    self->size = newSize;
    
    LOG_INFO("数组表", "保留列表元素", "成功保留 %d 个元素", retainedCount);
    return true;
}

/**
 * 判断数组表是否包含另一个数组表的所有元素
 * @param self ArrayList指针
 * @param other 另一个数组表指针
 * @param compare 比较函数指针，返回0表示元素相等
 * @return 是否包含另一个数组表的所有元素
 */
static bool arrayListContainsAll(struct ArrayList *self, struct ArrayList *other, int (*compare)(void *, void *)) {
    // 检查参数有效性
    if (self == NULL) {
        LOG_ERROR("数组表", "包含所有元素", "数组表指针为空");
        return false;
    }
    
    if (other == NULL) {
        LOG_ERROR("数组表", "包含所有元素", "另一个数组表指针为空");
        return false;
    }
    
    if (compare == NULL) {
        LOG_ERROR("数组表", "包含所有元素", "比较函数指针为空");
        return false;
    }
    
    // 特殊情况：other为空列表，返回true（空集合是任何集合的子集）
    if (other->size == 0) {
        LOG_INFO("数组表", "包含所有元素", "另一个数组表为空，视为包含所有元素");
        return true;
    }
    
    // 特殊情况：self为空列表且other不为空，返回false
    if (self->size == 0) {
        LOG_INFO("数组表", "包含所有元素", "数组表为空，无法包含另一个非空数组表的所有元素");
        return false;
    }
    
    // 遍历other中的每个元素，检查self是否包含
    for (int i = 0; i < other->size; i++) {
        bool found = false;
        // 在self中查找当前元素
        for (int j = 0; j < self->size; j++) {
            if (compare(self->data[j], other->data[i]) == 0) {
                found = true;
                break;
            }
        }
        
        // 如果other中的任何一个元素不在self中，返回false
        if (!found) {
            LOG_INFO("数组表", "包含所有元素", "不包含另一个数组表索引 %d 处的元素", i);
            return false;
        }
    }
    
    // 所有元素都找到了
    LOG_INFO("数组表", "包含所有元素", "数组表包含另一个数组表的所有元素");
    return true;
}

/**
 * 合并数组表，将另一个数组表的所有元素添加到当前数组表末尾
 * @param self 当前ArrayList指针
 * @param other 要合并的另一个ArrayList指针
 * @return 是否合并成功
 */
static bool arrayListMerge(struct ArrayList *self, struct ArrayList *other) {
    // 内部调用addAllIndex函数，在当前数组表末尾添加另一个数组表的所有元素
    // self->size 是末尾索引位置
    return arrayListAddAllIndex(self, self->size, other);
}

/**
 * 比较两个数组表是否相等
 * @param self ArrayList指针
 * @param other 另一个ArrayList指针
 * @return 两个数组表是否相等
 */
static bool arrayListEquals(struct ArrayList *self, struct ArrayList *other, int (*compare)(void *, void *)) {
    // 检查参数有效性
    if (self == NULL || other == NULL) {
        LOG_ERROR("数组表", "比较相等", "数组表指针为空");
        return false;
    }
    
    // 快速检查：如果是同一个对象（地址相等），则必定相等
    if (self == other) {
        LOG_INFO("数组表", "比较相等", "数组表地址相同，必定相等");
        return true;
    }
    
    // 检查大小是否相等
    if (self->size != other->size) {
        LOG_INFO("数组表", "比较相等", "数组表大小不同：self.size=%d, other.size=%d", 
                 self->size, other->size);
        return false;
    }
    
    // 逐元素比较
    for (int i = 0; i < self->size; i++) {
        // 如果是指针类型，这里直接比较指针是否相等
        // 在实际应用中，可能需要根据元素类型进行适当的深度比较
        if (compare(self->data[i], other->data[i]) != 0) {
            LOG_INFO("数组表", "比较相等", "索引%d处的元素不同", i);
            return false;
        }
    }
    
    LOG_INFO("数组表", "比较相等", "两个数组表内容完全相同");
    return true;
}

/**
 * 克隆，数组表的深拷贝
 * 克隆的数组表是一个新的数组表，每个元素也都深拷贝
 * @param self ArrayList指针
 * @return 克隆后的新ArrayList指针，若操作失败则返回NULL
 */
static struct ArrayList *arrayListClone(struct ArrayList *self) {
    // 检查参数有效性
    if (self == NULL) {
        LOG_ERROR("数组表", "克隆", "数组表指针为空");
        return NULL;
    }
    
    // 创建一个新的ArrayList，容量与原数组表相同
    struct ArrayList *clone = arrayListInit(self->capacity);
    if (clone == NULL) {
        LOG_ERROR("数组表", "克隆", "创建新数组表失败");
        return NULL;
    }
    
    // 确保新数组表有足够的容量（虽然已经初始化了相同的容量，但再次确保）
    if (!arrayListEnsureCapacity(clone, self->size)) {
        LOG_ERROR("数组表", "克隆", "确保容量失败");
        arrayListDestroy(clone);
        return NULL;
    }
    
    // 深拷贝每个元素
    // 注意：在C语言中，深拷贝需要知道如何拷贝具体的元素类型
    // 这里假设每个元素都是一个动态分配的内存块，需要使用合适的拷贝方法
    // 由于没有具体的元素拷贝函数，这里我们直接复制指针
    // 在实际应用中，可能需要传入一个拷贝函数指针来处理元素的深拷贝
    for (int i = 0; i < self->size; i++) {
        // 直接复制指针（浅拷贝）
        // 在实际使用时，调用者需要确保元素的生命周期管理
        clone->data[i] = self->data[i];
    }
    
    // 更新新数组表的大小
    clone->size = self->size;
    
    LOG_INFO("数组表", "克隆", "成功克隆数组表，大小为%d，容量为%d", clone->size, clone->capacity);
    return clone;
}

/**
 * 获取数组表中指定范围的子数组表
 * 子数组表是深拷贝，是一个新的数组表
 * @param self ArrayList指针
 * @param fromIndex 起始索引（包含）
 * @param toIndex 结束索引（不包含）
 * @return 子数组表指针，若操作失败则返回NULL
 */
static struct ArrayList *arrayListSubList(struct ArrayList *self, int fromIndex, int toIndex) {
    // 检查参数有效性
    if (self == NULL) {
        LOG_ERROR("数组表", "获取子列表", "数组表指针为空");
        return NULL;
    }
    
    // 检查索引范围是否有效
    if (fromIndex < 0 || toIndex > self->size || fromIndex > toIndex) {
        LOG_ERROR("数组表", "获取子列表", "索引范围 [ %d, %d ) 无效，有效范围为 [0, %d]", 
                 fromIndex, toIndex, self->size);
        return NULL;
    }
    
    // 计算子列表的大小
    int subListSize = toIndex - fromIndex;
    
    // 创建一个新的ArrayList，容量为子列表的大小
    struct ArrayList *subList = arrayListInit(subListSize);
    if (subList == NULL) {
        LOG_ERROR("数组表", "获取子列表", "创建新数组表失败");
        return NULL;
    }
    
    // 确保新数组表有足够的容量
    if (!arrayListEnsureCapacity(subList, subListSize)) {
        LOG_ERROR("数组表", "获取子列表", "确保容量失败");
        arrayListDestroy(subList);
        return NULL;
    }
    
    // 复制指定范围的元素到新数组表中
    // 与clone函数类似，这里假设直接复制指针，在实际应用中可能需要更深层次的拷贝
    for (int i = 0; i < subListSize; i++) {
        subList->data[i] = self->data[fromIndex + i];
    }
    
    // 更新新数组表的大小
    subList->size = subListSize;
    
    LOG_INFO("数组表", "获取子列表", "成功获取索引范围 [ %d, %d ) 的子数组表，大小为%d", 
             fromIndex, toIndex, subListSize);
    return subList;
}

/**
 * 将数组表从指定索引位置拆分为两个子数组表
 * @param self ArrayList指针
 * @param index 拆分索引位置
 * @return 包含两个子数组表指针的数组，第0个是修改后的原数组表，第1个是新建的数组表
 */
static struct ArrayList **arrayListSplit(struct ArrayList *self, int index) {
    // 检查参数有效性
    if (self == NULL) {
        LOG_ERROR("数组表", "拆分", "数组表指针为空");
        return NULL;
    }
    
    // 检查索引是否有效
    if (index < 0 || index > self->size) {
        LOG_ERROR("数组表", "拆分", "索引%d无效，有效范围为[0, %d]", index, self->size);
        return NULL;
    }
    
    // 创建返回的数组，包含两个ArrayList指针
    struct ArrayList **result = (struct ArrayList **)malloc(sizeof(struct ArrayList *) * 2);
    if (result == NULL) {
        LOG_ERROR("数组表", "拆分", "内存分配失败");
        return NULL;
    }
    
    // 第一个元素是原数组表（将被修改）
    result[0] = self;
    
    // 创建第二个数组表，用于存储index及之后的元素
    struct ArrayList *secondList = arrayListInit(self->size - index);
    if (secondList == NULL) {
        LOG_ERROR("数组表", "拆分", "创建第二个数组表失败");
        free(result);
        return NULL;
    }
    
    // 深拷贝元素到第二个数组表
    for (int i = index; i < self->size; i++) {
        secondList->data[i - index] = self->data[i];
    }
    secondList->size = self->size - index;
    
    // 修改原数组表，截断到index位置
    self->size = index;
    
    // 将第二个数组表放入结果中
    result[1] = secondList;
    
    LOG_INFO("数组表", "拆分", "成功将数组表从索引%d拆分为两个数组表，大小分别为%d和%d", 
             index, self->size, secondList->size);
    return result;
}

/**
 * 将数组表分组，根据指定的分组函数
 * @param self ArrayList指针
 * @param group 分组函数指针，返回分组ID
 * @return 分组后的数组表指针数组，以NULL结尾
 */
static struct ArrayList **arrayListGroup(struct ArrayList *self, int (*group)(void *)) {
    // 检查参数有效性
    if (self == NULL) {
        LOG_ERROR("数组表", "分组", "数组表指针为空");
        return NULL;
    }
    
    if (group == NULL) {
        LOG_ERROR("数组表", "分组", "分组函数指针为空");
        return NULL;
    }
    
    // 首先确定有多少个不同的分组
    // 为了简化，我们使用一个临时数组来跟踪已创建的分组
    // 这里使用一个合理的初始容量
    const int INITIAL_GROUP_CAPACITY = 10;
    struct ArrayList **groups = (struct ArrayList **)malloc(sizeof(struct ArrayList *) * (INITIAL_GROUP_CAPACITY + 1));
    if (groups == NULL) {
        LOG_ERROR("数组表", "分组", "内存分配失败");
        return NULL;
    }
    
    // 初始化分组数组，所有元素为NULL
    for (int i = 0; i < INITIAL_GROUP_CAPACITY + 1; i++) {
        groups[i] = NULL;
    }
    
    // 记录最大的分组ID
    int maxGroupId = -1;
    
    // 遍历原数组表中的每个元素
    for (int i = 0; i < self->size; i++) {
        void *element = self->data[i];
        
        // 调用分组函数获取分组ID
        int groupId = group(element);
        
        // 确保groupId为非负数
        if (groupId < 0) {
            LOG_WARN("数组表", "分组", "分组函数返回负数ID(%d)，跳过该元素", groupId);
            continue;
        }
        
        // 如果分组ID超过当前容量，需要扩容
        if (groupId >= INITIAL_GROUP_CAPACITY) {
            int newCapacity = groupId + 1;
            struct ArrayList **newGroups = (struct ArrayList **)realloc(groups, sizeof(struct ArrayList *) * (newCapacity + 1));
            if (newGroups == NULL) {
                LOG_ERROR("数组表", "分组", "扩容失败");
                // 释放已创建的分组
                for (int j = 0; j < INITIAL_GROUP_CAPACITY + 1; j++) {
                    if (groups[j] != NULL) {
                        arrayListDestroy(groups[j]);
                    }
                }
                free(groups);
                return NULL;
            }
            
            // 初始化新增的空间
            for (int j = INITIAL_GROUP_CAPACITY; j < newCapacity + 1; j++) {
                newGroups[j] = NULL;
            }
            
            groups = newGroups;
        }
        
        // 更新最大分组ID
        if (groupId > maxGroupId) {
            maxGroupId = groupId;
        }
        
        // 如果该分组还不存在，创建新的数组表
        if (groups[groupId] == NULL) {
            groups[groupId] = arrayListInit(DEFAULT_CAPACITY);
            if (groups[groupId] == NULL) {
                LOG_ERROR("数组表", "分组", "创建分组数组表失败");
                // 释放已创建的分组
                for (int j = 0; j <= maxGroupId; j++) {
                    if (groups[j] != NULL) {
                        arrayListDestroy(groups[j]);
                    }
                }
                free(groups);
                return NULL;
            }
        }
        
        // 将元素添加到对应的分组中
        if (!groups[groupId]->add(groups[groupId], element)) {
            LOG_WARN("数组表", "分组", "添加元素到分组%d失败", groupId);
        }
    }
    
    LOG_INFO("数组表", "分组", "成功将数组表按分组函数分为%d个组", maxGroupId + 1);
    return groups;
}

// 列表操作

/**
 * 将数组表转换为字符串
 * @param self 数组表指针
 * @return 字符串指针，需要手动释放
 */
static char *arrayListToString(struct ArrayList *self) {
    if (self == NULL) {
        LOG_WARN("数组表", "转换字符串", "数组表指针为空");
        char *result = (char *)malloc(8);
        if (result != NULL) {
            strcpy(result, "[NULL]");
        } else {
            LOG_ERROR("数组表", "转换字符串", "空数组表字符串内存分配失败");
        }
        return result;
    }
    
    // 计算所需字符串长度
    // 格式: [元素1, 元素2, ..., 元素n]
    int initialSize = 2; // [ ] 两个字符
    int separatorSize = 2; // ", " 两个字符
    int totalSize = initialSize;
    
    if (self->size > 0) {
        totalSize += (self->size - 1) * separatorSize;
        // 每个元素假设最多16个字符（足够显示指针地址）
        totalSize += self->size * 16;
    }
    
    // 分配字符串内存
    char *result = (char *)malloc(totalSize + 1); // +1 用于结束符
    if (result == NULL) {
        LOG_ERROR("数组表", "转换字符串", "字符串内存分配失败");
        return NULL;
    }
    
    // 初始化字符串
    result[0] = '[';
    result[1] = '\0';
    
    // 添加每个元素
    for (int i = 0; i < self->size; i++) {
        if (i > 0) {
            strcat(result, ", ");
        }
        
        // 将指针地址格式化为字符串
        char elementStr[17]; // 16个十六进制字符 + 1个结束符
        sprintf(elementStr, "%p", self->data[i]);
        strcat(result, elementStr);
    }
    
    // 添加结束括号
    strcat(result, "]");
    
    return result;
}

/**
 * 获取数组表的哈希值
 * @param self ArrayList指针
 * @return int 数组表的哈希值
 */
static int arrayListHashCode(struct ArrayList *self) {
    // 参数有效性检查
    if (self == NULL) {
        LOG_ERROR("数组表", "获取哈希值", "参数为NULL，返回-1");
        return -1; // 参数为NULL时返回-1表示错误
    }
    
    // 初始哈希值
    int hashCode = 1;
    
    // 基于size和capacity计算基础哈希值
    hashCode = 31 * hashCode + self->size;
    hashCode = 31 * hashCode + self->capacity;
    
    // 遍历所有元素，将元素指针值加入哈希计算
    for (int i = 0; i < self->size; i++) {
        // 使用指针的地址值作为元素的哈希贡献
        // 对于NULL元素，使用特殊值0
        size_t elementHash = (self->data[i] == NULL) ? 0 : (size_t)self->data[i];
        
        // 将元素哈希值加入总哈希值计算
        hashCode = 31 * hashCode + (int)(elementHash ^ (elementHash >> 32));
    }
    
    LOG_INFO("数组表", "获取哈希值", "数组表哈希值为%d", hashCode);
    
    return hashCode;
}

/**
 * 判断数组表是否为空
 * @param self ArrayList指针
 * @return bool 如果数组表为空返回true，否则返回false
 */
static bool arrayListIsEmpty(struct ArrayList *self) {
    // 参数有效性检查
    if (self == NULL) {
        LOG_ERROR("数组表", "判断是否为空", "参数为NULL，返回false");
        return false; // 参数为NULL时，认为不是空数组表
    }
    
    // 通过检查size是否为0来判断数组表是否为空
    bool isEmpty = (self->size == 0);
    
    LOG_INFO("数组表", "判断是否为空", "数组表%s为空", isEmpty ? "" : "不");
    
    return isEmpty;
}

/**
 * 在数组表指定位置添加另一个数组表的所有元素
 * @param self 当前ArrayList指针
 * @param index 添加位置的索引
 * @param other 要添加的另一个ArrayList指针
 * @return 是否添加成功
 */
static bool arrayListAddAllIndex(struct ArrayList *self, int index, struct ArrayList *other) {
    // 检查参数有效性
    if (self == NULL) {
        LOG_ERROR("数组表", "指定索引添加列表", "数组表指针为空");
        return false;
    }
    
    if (other == NULL) {
        LOG_WARN("数组表", "指定索引添加列表", "源数组表指针为空");
        return true; // 空列表视为成功添加（没有元素需要添加）
    }
    
    // 检查索引是否有效
    // 允许index等于size，表示添加到末尾（等同于addAll）
    if (index < 0 || index > self->size) {
        LOG_ERROR("数组表", "指定索引添加列表", "索引 %d 无效，有效范围为 [0, %d]", index, self->size);
        return false;
    }
    
    // 如果other列表为空，直接返回成功
    if (other->size == 0) {
        LOG_INFO("数组表", "指定索引添加列表", "源数组表为空，无需添加");
        return true;
    }
    
    // 计算添加后的总大小
    int newSize = self->size + other->size;
    
    // 确保有足够的容量
    if (newSize > self->capacity) {
        if (!arrayListEnsureCapacity(self, newSize)) {
            LOG_ERROR("数组表", "指定索引添加列表", "容量不足且扩容失败");
            return false;
        }
    }
    
    // 如果不是添加到末尾，需要将index及之后的元素后移
    if (index < self->size) {
        // 从最后一个元素开始，依次后移other->size位
        for (int i = self->size - 1; i >= index; i--) {
            self->data[i + other->size] = self->data[i];
        }
    }
    
    // 批量复制other列表中的元素到self列表的指定位置
    for (int i = 0; i < other->size; i++) {
        self->data[index + i] = other->data[i];
    }
    
    // 更新大小
    self->size = newSize;
    
    LOG_INFO("数组表", "指定索引添加列表", "成功在索引 %d 添加 %d 个元素", index, other->size);
    return true;
}

/**
 * 从ArrayList中删除指定范围的元素
 * @param self ArrayList指针
 * @param fromIndex 起始索引（包含）
 * @param toIndex 结束索引（不包含）
 * @return 是否删除成功
 */
static bool arrayListRemoveRange(struct ArrayList *self, int fromIndex, int toIndex) {
    // 检查参数有效性
    if (self == NULL) {
        LOG_ERROR("数组表", "范围删除", "数组表指针为空");
        return false;
    }
    
    // 检查索引是否有效
    if (fromIndex < 0 || toIndex > self->size || fromIndex > toIndex) {
        LOG_ERROR("数组表", "范围删除", "索引范围 [ %d, %d ) 无效，有效范围为 [0, %d]", 
                 fromIndex, toIndex, self->size);
        return false;
    }
    
    // 如果fromIndex等于toIndex，表示没有元素需要删除
    if (fromIndex == toIndex) {
        LOG_INFO("数组表", "范围删除", "索引范围 [ %d, %d ) 没有元素需要删除", fromIndex, toIndex);
        return true;
    }
    
    // 计算要删除的元素数量
    int removeCount = toIndex - fromIndex;
    
    // 将toIndex之后的元素前移，覆盖被删除的范围
    for (int i = toIndex; i < self->size; i++) {
        self->data[i - removeCount] = self->data[i];
    }
    
    // 更新大小
    self->size -= removeCount;
    
    LOG_INFO("数组表", "范围删除", "成功删除索引范围 [ %d, %d ) 的 %d 个元素", 
             fromIndex, toIndex, removeCount);
    return true;
}

/**
 * 截断数组表，重新设置大小为指定值，容量不缩容
 * @param self ArrayList指针
 * @param newSize 新的大小
 * @return 操作是否成功
 */
static bool arrayListTruncate(struct ArrayList *self, int newSize) {
    // 检查参数有效性
    if (self == NULL) {
        LOG_ERROR("数组表", "截断", "数组表指针为空");
        return false;
    }
    
    // 检查新大小是否合法
    if (newSize < 0) {
        LOG_ERROR("数组表", "截断", "新大小%d不能为负数", newSize);
        return false;
    }
    
    // 记录原始大小
    int oldSize = self->size;
    
    // 如果新大小小于原始大小，则截断
    if (newSize < oldSize) {
        self->size = newSize;
        LOG_INFO("数组表", "截断", "成功将数组表从大小%d截断到%d，容量保持为%d", 
                 oldSize, newSize, self->capacity);
    } 
    // 如果新大小大于原始大小但小于等于容量，则扩展大小
    else if (newSize > oldSize && newSize <= self->capacity) {
        self->size = newSize;
        // 注意：这里只是修改了大小，没有实际填充元素
        LOG_INFO("数组表", "截断", "成功将数组表从大小%d扩展到%d（未超过容量），容量保持为%d", 
                 oldSize, newSize, self->capacity);
    } 
    // 如果新大小大于容量，则需要先扩容
    else if (newSize > self->capacity) {
        LOG_ERROR("数组表", "截断", "新大小%d超过当前容量%d，请先调用ensureCapacity扩容", 
                 newSize, self->capacity);
        return false;
    }
    // 新大小等于原始大小，无需操作
    else {
        LOG_INFO("数组表", "截断", "新大小%d与当前大小相同，无需操作", newSize);
    }
    
    return true;
}

/**
 * 清空数组表，将所有元素设置为NULL
 * @param self ArrayList指针
 * @return void
 */
static bool arrayListClear(struct ArrayList *self) {
    // 参数有效性检查
    if (self == NULL) {
        LOG_ERROR("数组表", "清空操作", "参数为NULL，清空失败");
        return false;
    }
    
    // 边界条件：空数组表直接返回
    if (self->size == 0) {
        LOG_INFO("数组表", "清空操作", "数组表已为空，无需清空");
        return true;
    }
    
    // 将所有元素设置为NULL
    for (int i = 0; i < self->size; i++) {
        self->data[i] = NULL;
    }
    
    // 重置size为0
    self->size = 0;
    
    LOG_INFO("数组表", "清空操作", "成功清空数组表，元素数量已重置为0");
    return true;
}

/**
 * 正序遍历数组表，对每个元素执行指定操作
 * @param self ArrayList指针
 * @param action 对每个元素执行的操作函数
 */
static void arrayListForEach(struct ArrayList *self, void (*action)(void *)) {
    // 参数验证
    if (self == NULL) {
        LOG_ERROR("数组表", "遍历元素", "数组表指针为空");
        return;
    }
    
    if (action == NULL) {
        LOG_ERROR("数组表", "遍历元素", "操作函数指针为空");
        return;
    }
    
    // 检查数组表是否为空
    if (self->size == 0) {
        LOG_DEBUG("数组表", "遍历元素", "数组表为空，无需遍历");
        return;
    }
    
    // 正序遍历数组表，对每个元素执行指定操作
    for (int i = 0; i < self->size; i++) {
        action(self->data[i]);
        LOG_DEBUG("数组表", "遍历元素", "索引(%d)的元素已处理", i);
    }
    
    LOG_DEBUG("数组表", "遍历元素", "正序遍历操作完成，数组表大小为(%d)", self->size);
}

/**
 * 逆序遍历数组表，对每个元素执行指定操作
 * @param self ArrayList指针
 * @param action 对每个元素执行的操作函数
 */
static void arrayListForEachReverse(struct ArrayList *self, void (*action)(void *)) {
    // 参数验证
    if (self == NULL) {
        LOG_ERROR("数组表", "逆序遍历元素", "数组表指针为空");
        return;
    }
    
    if (action == NULL) {
        LOG_ERROR("数组表", "逆序遍历元素", "操作函数指针为空");
        return;
    }
    
    // 检查数组表是否为空
    if (self->size == 0) {
        LOG_DEBUG("数组表", "逆序遍历元素", "数组表为空，无需遍历");
        return;
    }
    
    // 逆序遍历数组表，对每个元素执行指定操作
    for (int i = self->size - 1; i >= 0; i--) {
        action(self->data[i]);
        LOG_DEBUG("数组表", "逆序遍历元素", "索引(%d)的元素已处理", i);
    }
    
    LOG_DEBUG("数组表", "逆序遍历元素", "逆序遍历操作完成，数组表大小为(%d)", self->size);
}

/**
 * 反转数组表元素的顺序
 * @param self ArrayList指针
 */
static void arrayListReverse(struct ArrayList *self) {
    // 参数验证
    if (self == NULL) {
        LOG_ERROR("数组表", "反转元素", "数组表指针为空");
        return;
    }
    
    // 检查数组表是否为空或只有一个元素
    if (self->size <= 1) {
        LOG_DEBUG("数组表", "反转元素", "数组表为空或只有一个元素，无需反转");
        return;
    }
    
    // 使用双指针法反转数组
    int left = 0;
    int right = self->size - 1;
    void *temp;
    
    while (left < right) {
        // 交换元素
        temp = self->data[left];
        self->data[left] = self->data[right];
        self->data[right] = temp;
        
        LOG_DEBUG("数组表", "反转元素", "交换索引(%d)和索引(%d)的元素", left, right);
        
        // 移动指针
        left++;
        right--;
    }
    
    LOG_DEBUG("数组表", "反转元素", "数组表反转操作完成，数组表大小为(%d)", self->size);
}

/**
 * 对数组表中的元素进行排序（快速排序实现）
 * @param self ArrayList指针
 * @param type 排序类型(0:升序, 1:降序)
 * @param compare 比较函数指针
 */
static void arrayListSort(struct ArrayList *self, int type, int (*compare)(void *, void *)) {
    // 检查参数有效性
    if (self == NULL) {
        LOG_ERROR("数组表", "排序", "数组表指针为空");
        return;
    }
    
    if (compare == NULL) {
        LOG_ERROR("数组表", "排序", "比较函数指针为空");
        return;
    }
    
    // 检查排序类型
    if (type != 0 && type != 1) {
        LOG_WARN("数组表", "排序", "排序类型%d无效，默认为升序(0)", type);
        type = 0;
    }
    
    // 如果数组表大小小于等于1，无需排序
    if (self->size <= 1) {
        LOG_INFO("数组表", "排序", "数组表大小为%d，无需排序", self->size);
        return;
    }
    
    // 调用快速排序进行排序
    quickSort(self->data, 0, self->size - 1, type, compare);
    
    LOG_INFO("数组表", "排序", "成功对数组表进行%s排序，大小为%d", 
             type == 0 ? "升序" : "降序", self->size);
}

// 排序辅助函数

/**
 * 快速排序辅助函数
 * @param data 数据数组
 * @param low 起始索引
 * @param high 结束索引
 * @param type 排序类型
 * @param compare 比较函数
 */
static void quickSort(void **data, int low, int high, int type, int (*compare)(void *, void *)) {
    if (low < high) {
        // 获取分区点
        int pi = partition(data, low, high, type, compare);
        
        // 递归排序分区点左边的元素
        quickSort(data, low, pi - 1, type, compare);
        
        // 递归排序分区点右边的元素
        quickSort(data, pi + 1, high, type, compare);
    }
}

/**
 * 快速排序分区函数
 * @param data 数据数组
 * @param low 起始索引
 * @param high 结束索引
 * @param type 排序类型
 * @param compare 比较函数
 * @return 分区点索引
 */
static int partition(void **data, int low, int high, int type, int (*compare)(void *, void *)) {
    // 选择最右边的元素作为基准
    void *pivot = data[high];
    
    // i表示小于基准元素区域的边界
    int i = low - 1;
    
    // 遍历low到high-1的元素
    for (int j = low; j < high; j++) {
        int cmpResult = compare(data[j], pivot);
        
        // 根据排序类型判断是否需要交换
        if ((type == 0 && cmpResult < 0) || (type == 1 && cmpResult > 0)) {
            // 扩展小于基准元素的区域
            i++;
            
            // 交换元素
            void *temp = data[i];
            data[i] = data[j];
            data[j] = temp;
        }
    }
    
    // 将基准元素放到正确的位置
    void *temp = data[i + 1];
    data[i + 1] = data[high];
    data[high] = temp;
    
    // 返回基准元素的索引
    return i + 1;
}

// 属性操作

/**
 * 获取数组表大小
 * @param self ArrayList指针
 * @return int 数组表中元素的数量
 */
static int arrayListGetSize(struct ArrayList *self) {
    // 参数有效性检查
    if (self == NULL) {
        LOG_ERROR("数组表", "获取大小", "参数为NULL，返回-1");
        return -1; // 参数为NULL时返回-1表示错误
    }
    
    LOG_INFO("数组表", "获取大小", "数组表大小为%d", self->size);
    
    return self->size;
}

/**
 * 获取数组表的容量
 * @param self ArrayList指针
 * @return int 数组表的容量
 */
static int arrayListGetCapacity(struct ArrayList *self) {
    // 参数有效性检查
    if (self == NULL) {
        LOG_ERROR("数组表", "获取容量", "参数为NULL，返回-1");
        return -1; // 参数为NULL时返回-1表示错误
    }
    
    LOG_INFO("数组表", "获取容量", "数组表容量为%d", self->capacity);
    
    return self->capacity;
}

/**
 * 确保ArrayList具有足够的容量
 * @param self ArrayList指针
 * @param minCapacity 最小需要的容量
 * @return 是否成功确保容量
 */
static bool arrayListEnsureCapacity(struct ArrayList *self, int minCapacity) {
    if (self == NULL) {
        LOG_ERROR("数组表", "确保容量", "数组表指针为空");
        return false;
    }
    
    // 如果当前容量已经足够，直接返回
    if (self->capacity >= minCapacity) {
        return true;
    }
    
    // 计算新容量，使用EXPAND_FACTOR进行扩容
    int newCapacity = self->capacity * EXPAND_FACTOR;
    // 如果扩容后仍不够，则使用所需的最小容量
    if (newCapacity < minCapacity) {
        newCapacity = minCapacity;
    }
    
    LOG_INFO("数组表", "扩容", "容量从 %d 扩展到 %d", self->capacity, newCapacity);
    
    // 重新分配内存
    void **newData = (void **)realloc(self->data, sizeof(void *) * newCapacity);
    if (newData == NULL) {
        LOG_ERROR("数组表", "扩容", "内存重新分配失败");
        return false;
    }
    
    // 更新数据指针和容量
    self->data = newData;
    self->capacity = newCapacity;
    
    return true;
}
